import React, { useState, useEffect } from 'react';
import DataTable from '../../UI/DataTable';
import PageContainer from '../../UI/PageContainer';
import AttachmentDropdown from '../../UI/AttachmentDropdown';
import ErrorToast from '../../UI/ErrorToast';
import ConfirmDialog from '../../UI/ConfirmDialog';
import './JournalPage.css';

const JournalPage = () => {
  const [data, setData] = useState([]);
  const [total, setTotal] = useState(0); // 总记录数
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState('');
  const [currentPage, setCurrentPage] = useState(1); // 当前页码
  const [pageSize, setPageSize] = useState(10); // 每页显示数量
  const [searchInput, setSearchInput] = useState(''); // 搜索框输入值（即时更新）
  const [searchTerm, setSearchTerm] = useState(''); // 实际用于查询的搜索词（防抖后）
  const [filters, setFilters] = useState({}); // 筛选条件
  const [stats, setStats] = useState([
    { value: 0, label: '总论文数' },
    { value: 0, label: '第一作者' },
    { value: 0, label: '通讯作者' }
  ]);
  const [deleteConfirm, setDeleteConfirm] = useState({
    isOpen: false,
    id: null
  });

  // 搜索框防抖：当用户停止输入 300ms 后才更新 searchTerm
  useEffect(() => {
    const debounceTimer = setTimeout(() => {
      setSearchTerm(searchInput);
      setCurrentPage(1); // 搜索时重置到第一页
    }, 300);

    // 清理函数：如果用户继续输入，取消之前的定时器
    return () => clearTimeout(debounceTimer);
  }, [searchInput]);

  // 从数据库加载数据（带分页、搜索和筛选）
  useEffect(() => {
    loadData(currentPage, pageSize, searchTerm, filters);
  }, [currentPage, pageSize, searchTerm, filters]);

  const loadData = async (page = 1, size = 10, search = '', filterConditions = {}) => {
    setLoading(true);
    setError('');
    
    try {
      if (window.electronAPI && window.electronAPI.getJournalPapers) {
        // 计算分页参数
        const limit = size;
        const offset = (page - 1) * size;
        const pagination = { limit, offset };
        
        // 构建查询条件：将搜索词和筛选条件组合
        const conditions = {
          searchKeyword: search || null, // 搜索关键词（用于模糊搜索）
          ...filterConditions // 筛选条件（等值查询）
        };
        
        const result = await window.electronAPI.getJournalPapers(conditions, pagination);
        
        if (result.success) {
          setData(result.data || []);
          setTotal(result.total || 0);
          // 更新统计信息（需要查询所有数据来计算统计，这里先使用当前页数据作为估算）
          // 如果需要精确统计，可以单独查询统计信息
          updateStats(result.data || []);
        } else {
          setError(result.error || '加载数据失败');
          setData([]);
          setTotal(0);
        }
      } else {
        console.warn('Electron API 不可用');
        setError('数据库连接不可用');
        setData([]);
        setTotal(0);
      }
    } catch (error) {
      console.error('加载数据错误:', error);
      setError('加载数据失败，请稍后重试');
      setData([]);
      setTotal(0);
    } finally {
      setLoading(false);
    }
  };

  // 更新统计信息
  const updateStats = (papers) => {
    if (!papers || papers.length === 0) {
      setStats([
        { value: 0, label: '总论文数' },
        { value: 0, label: '第一作者' },
        { value: 0, label: '通讯作者' }
      ]);
      return;
    }

    const total = papers.length;
    const firstAuthor = papers.filter(p => p.author_ranking === '第一作者').length;
    const correspondingAuthor = papers.filter(p => p.author_ranking === '通讯作者').length;

    setStats([
      { value: total, label: '总论文数' },
      { value: firstAuthor, label: '第一作者' },
      { value: correspondingAuthor, label: '通讯作者' }
    ]);
  };

  // 处理编辑
  const handleEdit = (rowData) => {
    // 编辑功能由 DataTable 内部处理，这里只需要记录日志
    console.log('编辑条目:', rowData);
  };

  // 处理删除
  const handleDelete = (id) => {
    if (!id) {
      setError('无法删除：缺少条目ID');
      return;
    }

    // 显示确认对话框
    setDeleteConfirm({
      isOpen: true,
      id: id
    });
  };

  // 确认删除
  const handleConfirmDelete = async () => {
    const id = deleteConfirm.id;
    if (!id) return;

    // 关闭对话框
    setDeleteConfirm({ isOpen: false, id: null });

    try {
      setLoading(true);
      setError('');
      
      if (window.electronAPI && window.electronAPI.deleteJournalPaper) {
        const result = await window.electronAPI.deleteJournalPaper(id);
        if (result.success) {
          // 删除成功，重新加载当前页数据
          await loadData(currentPage, pageSize, searchTerm, filters);
        } else {
          setError(result.error || '删除失败');
        }
      } else {
        setError('数据库连接不可用');
      }
    } catch (error) {
      console.error('删除数据错误:', error);
      setError('删除数据失败，请稍后重试');
    } finally {
      setLoading(false);
    }
  };

  // 取消删除
  const handleCancelDelete = () => {
    setDeleteConfirm({ isOpen: false, id: null });
  };

  // 处理提交编辑或新建
  const handleSubmit = async (formData, uploadedFiles, id, initialUploadedFiles = {}) => {
    // 注意：不设置 loading 状态，避免影响编辑页面的显示
    // 编辑页面的加载状态应该由 DataTable 或 GenericEditPage 内部管理
    
    const updatedFormData = { ...formData };
    const savedFiles = []; // 记录已保存的文件路径，用于错误回滚
    let recordId = id; // 记录ID，用于文件保存和数据库操作
    const deleteFileErrors = []; // 记录删除文件时的错误
    
    try {
      // 第一步（仅编辑模式）：检测并删除被移除的文件，并更新文件名字段
      console.log('=== 开始保存流程 ===');
      console.log('记录ID:', id);
      console.log('初始文件列表:', initialUploadedFiles);
      console.log('当前文件列表:', uploadedFiles);
      
      const deletedFilesMap = {}; // 记录每个上传区域需要保留的文件名
      if (id && initialUploadedFiles && Object.keys(initialUploadedFiles).length > 0) {
        console.log('✓ 进入文件删除检测逻辑，上传区域数量:', Object.keys(initialUploadedFiles).length);
        for (const [uploadAreaKey, initialFiles] of Object.entries(initialUploadedFiles)) {
          console.log(`  检查上传区域: ${uploadAreaKey}, 初始文件数: ${initialFiles?.length || 0}`);
          if (uploadAreaKey.endsWith('_url') && initialFiles && initialFiles.length > 0) {
            console.log(`    ✓ 区域 ${uploadAreaKey} 有初始文件，开始比较`);
            // 获取当前文件列表
            const currentFiles = uploadedFiles[uploadAreaKey] || [];
            
            // 提取初始文件和新文件的文件名（用于比较）
            const initialFileNames = new Set(
              initialFiles.map(f => f.fileName || f.name).filter(Boolean)
            );
            const currentFileNames = new Set(
              currentFiles.map(f => {
                // 如果是 File 对象，使用 name；如果是已有文件对象，使用 fileName 或 name
                if (f instanceof File) {
                  return f.name;
                }
                return f.fileName || f.name;
              }).filter(Boolean)
            );
            
            // 找出被删除的文件（在初始文件中但不在当前文件中）
            const deletedFileNames = Array.from(initialFileNames).filter(
              fileName => !currentFileNames.has(fileName)
            );
            
            // 找出保留的文件名（在当前文件中且不是新上传的 File 对象）
            const keptFileNames = currentFiles
              .filter(f => !(f instanceof File))
              .map(f => f.fileName || f.name)
              .filter(Boolean);
            
            // 删除被移除的文件
            if (deletedFileNames.length > 0) {
              console.log(`检测到 ${deletedFileNames.length} 个文件需要删除:`, deletedFileNames);
              for (const fileName of deletedFileNames) {
                try {
                  // 清理文件名，移除路径分隔符（只保留文件名）
                  const cleanFileName = fileName.split(/[/\\]/).pop();
                  
                  if (window.electronAPI && window.electronAPI.deleteFile) {
                    console.log(`准备删除文件 - 记录ID: ${id}, 文件名: ${cleanFileName}`);
                    const deleteResult = await window.electronAPI.deleteFile('journal', id, cleanFileName);
                    if (deleteResult && deleteResult.success) {
                      console.log(`✓ 已成功删除文件: ${cleanFileName}`);
                    } else {
                      const errorMsg = `删除文件失败: ${cleanFileName} - ${deleteResult?.error || '未知错误'}`;
                      console.error(`✗ ${errorMsg}`);
                      deleteFileErrors.push(errorMsg);
                    }
                  } else {
                    const errorMsg = '文件删除API不可用';
                    console.error(errorMsg);
                    deleteFileErrors.push(errorMsg);
                  }
                } catch (error) {
                  const errorMsg = `删除文件异常: ${fileName} - ${error.message}`;
                  console.error(`✗ ${errorMsg}`, error);
                  deleteFileErrors.push(errorMsg);
                  // 不抛出错误，继续处理其他文件
                }
              }
            } else {
              console.log(`    没有需要删除的文件 (区域: ${uploadAreaKey})`);
            }
            
            // 记录保留的文件名（先记录保留的，新上传的文件会在后续步骤中添加）
            deletedFilesMap[uploadAreaKey] = keptFileNames;
          } else {
            console.log(`    ✗ 区域 ${uploadAreaKey} 不符合删除条件 (是否以_url结尾: ${uploadAreaKey.endsWith('_url')}, 初始文件数: ${initialFiles?.length || 0})`);
          }
        }
      } else {
        console.log('✗ 不进入文件删除检测逻辑 - 原因:', {
          hasId: !!id,
          hasInitialFiles: !!(initialUploadedFiles && Object.keys(initialUploadedFiles).length > 0),
          initialUploadedFilesKeys: initialUploadedFiles ? Object.keys(initialUploadedFiles) : []
        });
      }
      
      // 第二步：如果是新建记录，先创建记录获取 ID（文件路径设为空字符串）
      if (!id) {
        // 先创建记录（不含文件路径），获取新记录的 ID
        const dataWithoutFiles = { ...updatedFormData };
        // 将所有 _url 字段设为空字符串
        Object.keys(dataWithoutFiles).forEach(key => {
          if (key.endsWith('_url')) {
            dataWithoutFiles[key] = '';
          }
        });
        
        if (window.electronAPI && window.electronAPI.createJournalPaper) {
          const createResult = await window.electronAPI.createJournalPaper(dataWithoutFiles);
          if (!createResult.success) {
            throw new Error(createResult.error || '创建记录失败');
          }
          recordId = createResult.id;
        } else {
          throw new Error('数据库连接不可用');
        }
      }
      
      // 第三步：如果有上传的文件，先上传文件到持久化目录，获取文件名并填入 formData
      if (uploadedFiles && Object.keys(uploadedFiles).length > 0) {
        // 处理每个上传区域的文件
        for (const [uploadAreaKey, files] of Object.entries(uploadedFiles)) {
          if (files && files.length > 0 && uploadAreaKey.endsWith('_url')) {
            // 保存文件并获取文件名（数据库中只存储文件名）
            const fileNames = await Promise.all(
              files.map(async (file) => {
                // 检查是否是 File 对象（新上传的文件）
                if (file instanceof File) {
                  // 新上传的文件，需要保存到持久化目录
                  if (window.electronAPI && window.electronAPI.saveFile) {
                    try {
                      const saveResult = await window.electronAPI.saveFile(file, 'journal', recordId, uploadAreaKey);
                      if (saveResult.success) {
                        // 记录已保存的文件名和相关信息，用于错误回滚
                        savedFiles.push({
                          fileName: saveResult.fileName,
                          recordType: 'journal',
                          recordId: recordId
                        });
                        return saveResult.fileName;
                      } else {
                        throw new Error(saveResult.error || '保存文件失败');
                      }
                    } catch (error) {
                      console.error('保存文件失败:', error);
                      throw error;
                    }
                  } else {
                    throw new Error('文件保存功能不可用');
                  }
                } else if (file && typeof file === 'object') {
                  // 已有文件对象（包含 fileName, recordType, recordId）
                  // 直接返回文件名，不需要重新保存
                  if (file.fileName) {
                    return file.fileName;
                  } else if (file.name) {
                    // 如果只有 name 属性，也使用它
                    return file.name;
                  } else {
                    // 不应该出现这种情况，但为了安全返回空字符串
                    console.warn('文件对象格式不正确:', file);
                    return '';
                  }
                } else if (typeof file === 'string') {
                  // 如果直接是字符串（文件名），直接返回
                  return file;
                } else {
                  // 其他情况，不应该出现
                  console.warn('未知的文件格式:', file);
                  return '';
                }
              })
            );
            
            // 将文件名填入对应的 _url 字段（多个文件用逗号分隔）
            // 注意：数据库中存储的是文件名，不是完整路径
            // 过滤掉空字符串
            const validFileNames = fileNames.filter(name => name && name.trim() !== '');
            updatedFormData[uploadAreaKey] = validFileNames.join(',');
            
            // 更新 deletedFilesMap，移除已处理的区域
            delete deletedFilesMap[uploadAreaKey];
          }
        }
        
        // 处理只删除了文件但没有上传新文件的情况
        for (const [uploadAreaKey, keptFileNames] of Object.entries(deletedFilesMap)) {
          // 只保留的文件名（没有新上传的文件）
          updatedFormData[uploadAreaKey] = keptFileNames.join(',');
        }
        
        // 第四步：更新记录，将文件名填入数据库
        if (window.electronAPI && window.electronAPI.updateJournalPaper) {
          const updateResult = await window.electronAPI.updateJournalPaper(recordId, updatedFormData);
          if (!updateResult.success) {
            // 更新失败，删除已保存的文件（如果是新建，还需要删除记录）
            for (const fileInfo of savedFiles) {
              try {
                if (window.electronAPI && window.electronAPI.deleteFile) {
                  await window.electronAPI.deleteFile(fileInfo.recordType, fileInfo.recordId, fileInfo.fileName);
                }
              } catch (error) {
                console.error('删除文件失败:', error);
              }
            }
            // 如果是新建的记录，删除记录
            if (!id && recordId) {
              try {
                if (window.electronAPI && window.electronAPI.deleteJournalPaper) {
                  await window.electronAPI.deleteJournalPaper(recordId);
                }
              } catch (error) {
                console.error('删除记录失败:', error);
              }
            }
            throw new Error(updateResult.error || '更新文件名失败');
          }
        }
      } else {
        // 如果没有上传文件，仍然需要更新其他字段的修改（编辑模式）
        // 此时 updatedFormData 中 _url 字段应该保持原有的文件名不变
        if (recordId && window.electronAPI && window.electronAPI.updateJournalPaper) {
          const updateResult = await window.electronAPI.updateJournalPaper(recordId, updatedFormData);
          if (!updateResult.success) {
            throw new Error(updateResult.error || '更新记录失败');
          }
        }
      }
      
      // 第五步：成功后重新加载当前页数据并返回列表
      await loadData(currentPage, pageSize, searchTerm, filters);
      
      // 如果有删除文件的错误，显示警告（但不阻止保存）
      if (deleteFileErrors.length > 0) {
        console.warn('部分文件删除失败:', deleteFileErrors);
        // 可以选择性地显示警告给用户（使用 alert 或 ErrorToast）
        // 这里使用 alert，因为 ErrorToast 在保存成功后可能已经被隐藏
        const errorSummary = deleteFileErrors.slice(0, 3).join('\n');
        const moreErrors = deleteFileErrors.length > 3 ? `\n...还有 ${deleteFileErrors.length - 3} 个错误` : '';
        alert(`保存成功，但有 ${deleteFileErrors.length} 个文件删除失败：\n${errorSummary}${moreErrors}\n\n请检查文件是否已被手动删除，或联系技术支持。`);
      }
    } catch (error) {
      // 如果出错，已保存的文件会在 catch 中处理
      throw error;
    }
  };

  const columns = [
    {
      key: 'title',
      title: '标题',
      width: '250px',
      render: (value) => (
        <div className="journal-page__title">{value}</div>
      )
    },
    { 
      key: 'author', 
      title: '作者', 
      width: '150px'
    },
    {
      key: 'author_ranking',
      title: '作者位次',
      width: '100px',
      render: (value) => (
        <span className={`journal-page__rank-badge journal-page__rank-badge--${value}`}>
          {value}
        </span>
      )
    },
    {
      key: 'keywords', 
      title: '关键词', 
      width: '200px',
      render: (value) => (
        <div className="journal-page__keywords">{value}</div>
      )
    },
    { 
      key: 'journal_name', 
      title: '期刊名称', 
      width: '150px' 
    },
    { 
      key: 'journal_abbreviation', 
      title: '期刊缩写', 
      width: '120px' 
    },
    { 
      key: 'publication_date', 
      title: '发表日期', 
      width: '120px' 
    },
    {
      key: 'volume_number',
      title: '卷号',
      width: '80px'
    },
    { 
      key: 'page_numbers', 
      title: '页码', 
      width: '100px' 
    },
    {
      key: 'jcr_quartile',
      title: 'JCR分区',
      width: '100px',
      render: (value) => (
        <span className="journal-page__quartile-badge">{value}</span>
      )
    },
    {
      key: 'sci_quartile',
      title: 'SCI分区',
      width: '100px',
      render: (value) => (
        <span className="journal-page__quartile-badge">{value}</span>
      )
    },
    {
      key: 'other_level',
      title: '其他级别',
      width: '120px',
      render: (value) => (
        <span className="journal-page__type-badge">{value}</span>
      )
    },
    { 
      key: 'field_of_expertise', 
      title: '专业领域', 
      width: '120px' 
    },
    { 
      key: 'impact_factor', 
      title: '影响因子', 
      width: '100px' 
    },
    { 
      key: 'number_of_citations', 
      title: '被引次数', 
      width: '100px' 
    },
    {
      key: 'paper_file_url',
      title: '论文原文',
      width: '180px',
      render: (value, row) => (
        <AttachmentDropdown attachmentUrl={value} recordType="journal" recordId={row.id} />
      )
    },
    {
      key: 'attachment_url',
      title: '论文附件',
      width: '180px',
      render: (value, row) => (
        <AttachmentDropdown attachmentUrl={value} recordType="journal" recordId={row.id} />
      )
    },
    {
      key: 'actions',
      title: '操作',
      width: '120px',
      render: (value, row, { onEdit, onDelete }) => (
        <div>
          <a 
            className="data-table__action-link data-table__action-link--edit"
            onClick={() => onEdit && onEdit(row)}
          >
            编辑
          </a>
          <a 
            className="data-table__action-link data-table__action-link--delete"
            onClick={() => onDelete && onDelete(row.id)}
          >
            删除
          </a>
        </div>
      )
    }
  ];

  return (
    <PageContainer className="journal-page">
      <ErrorToast 
        message={error} 
        duration={3000}
        onClose={() => setError('')}
      />
      <ConfirmDialog
        isOpen={deleteConfirm.isOpen}
        title="确认删除"
        message="确定要删除这条记录吗？此操作不可恢复。"
        confirmText="删除"
        cancelText="取消"
        onConfirm={handleConfirmDelete}
        onCancel={handleCancelDelete}
      />
      <DataTable
        data={data}
        total={total}
        columns={columns}
        loading={loading}
        showSearch={true}
        title="期刊论文"
        titleIcon="journal"
        editType="journal"
        searchPlaceholder="搜索标题、作者..."
        filterOptions={['已发表', '待发表', '审稿中']}
        onNew={() => console.log('新建期刊论文')}
        onEdit={handleEdit}
        onDelete={handleDelete}
        onSubmit={handleSubmit}
        onFilter={() => console.log('筛选期刊论文')}
        onSearchChange={(value) => {
          // 只更新搜索框输入值，防抖逻辑在 useEffect 中处理
          setSearchInput(value);
        }}
        onFilterChange={(newFilters) => {
          // 将 DataFilterModal 的字段名转换为数据库字段名
          const mappedFilters = {};
          const fieldMapping = {
            'author': 'author',
            'authorOrder': 'author_ranking',
            'keywords': 'keywords',
            'journalName': 'journal_name',
            'foundedDate': 'publication_date', // 注意：这里可能需要根据实际需求调整
            'jcrPartition': 'jcr_quartile',
            'sciPartition': 'sci_quartile',
            'otherLevel': 'other_level',
            'domain': 'field_of_expertise',
            'impactFactor': 'impact_factor',
            'citationCount': 'number_of_citations'
          };
          
          Object.keys(newFilters).forEach(key => {
            const dbField = fieldMapping[key];
            if (dbField && newFilters[key] !== null && newFilters[key] !== undefined && newFilters[key] !== '') {
              mappedFilters[dbField] = newFilters[key];
            }
          });
          
          setFilters(mappedFilters);
          setCurrentPage(1); // 筛选时重置到第一页
        }}
        showPagination={true}
        pageSize={pageSize}
        currentPage={currentPage}
        onPageChange={setCurrentPage}
        onPageSizeChange={setPageSize}
        stats={stats}
        showStats={true}
      />
    </PageContainer>
  );
};

export default JournalPage;